home *** CD-ROM | disk | FTP | other *** search
/ Aminet 48 / Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_libs.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-02-13  |  48.8 KB  |  1,326 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28.  
  29.  
  30. #include "system_headers.h"
  31.  
  32. #define KEYMAPRESNAME   "keymap.resource"
  33.  
  34. int  libcnt,devcnt,rescnt;
  35.  
  36. static APTR LibPool = NULL, DevPool = NULL, ResPool = NULL;
  37.  
  38. __asm __saveds LONG liblist_dspfunc(register __a2 char **array, register __a1 struct LibEntry *libentry, register __a0 struct Hook *hook)
  39. {
  40.    if (libentry) {
  41.       *array++ = libentry->lib_address;
  42.       *array++ = libentry->lib_name;
  43.       *array++ = libentry->lib_pri;
  44.       *array++ = libentry->lib_ver;
  45.       *array++ = libentry->lib_ocnt;
  46.       *array++ = libentry->lib_rcnt;
  47.       *array++ = libentry->lib_type;
  48.       *array   = NULL;
  49.    } else {
  50.       *array++ = ESC "bAddress";
  51.       *array++ = ESC "bln_Name";
  52.       *array++ = ESC "bln_Pri";
  53.       *array++ = ESC "bVersion";
  54.       *array++ = ESC "bOpenC";
  55.       *array++ = ESC "bRPC";
  56.       *array++ = ESC "bln_Type";
  57.       *array   = NULL;
  58.    }
  59.    return(0);
  60. }
  61.  
  62. struct Hook liblist_dsphook = {
  63.  {NULL, NULL},
  64.  (ULONG (* )())liblist_dspfunc,
  65.  NULL, NULL
  66. };
  67.  
  68. static struct FSEntry {
  69.    struct FSEntry *fs_Next;
  70.    char fs_FileSystem[16];
  71.    char fs_DOSType[16];
  72.    char fs_Version[16];
  73.    char fs_Creator[64];
  74. };
  75.  
  76. __asm __saveds LONG fsentry_dspfunc(register __a2 char **array, register __a1 struct FSEntry *fsentry, register __a0 struct Hook *hook)
  77. {
  78.    if (fsentry) {
  79.       *array++ = fsentry->fs_FileSystem;
  80.       *array++ = fsentry->fs_DOSType;
  81.       *array++ = fsentry->fs_Version;
  82.       *array++ = fsentry->fs_Creator;
  83.       *array   = NULL;
  84.    } else {
  85.       *array++ = ESC "bFileSystem";
  86.       *array++ = ESC "bfse_DosType";
  87.       *array++ = ESC "bfse_Version";
  88.       *array++ = ESC "bfse_Creator";
  89.       *array   = NULL;
  90.    }
  91.    return(0);
  92. }
  93.  
  94. struct Hook fsentry_dsphook = {
  95.  {NULL, NULL},
  96.  (ULONG (* )())fsentry_dspfunc,
  97.  NULL, NULL
  98. };
  99.  
  100. __asm __saveds LONG fsentry_cmpfunc(register __a1 struct FSEntry *fsentry1, register __a2 struct FSEntry *fsentry2)
  101. {
  102.     return strcmpi(fsentry1->fs_FileSystem, fsentry2->fs_FileSystem);
  103. }
  104.  
  105. struct Hook fsentry_cmphook = {
  106.  {NULL, NULL},
  107.  (ULONG (* )())fsentry_cmpfunc,
  108.  NULL, NULL
  109. };
  110.  
  111. static struct NSDCmdEntry {
  112.    struct NSCmdEntry *nce_Next;
  113.    UWORD nce_Number;
  114.    char nce_DecNumber[16];
  115.    char nce_HexNumber[16];
  116.    char nce_CmdName[64];
  117. };
  118.  
  119. __asm __saveds LONG nsdcmdentry_dspfunc(register __a2 char **array, register __a1 struct NSDCmdEntry *nsdcmdentry, register __a0 struct Hook *hook)
  120. {
  121.    if (nsdcmdentry) {
  122.       *array++ = nsdcmdentry->nce_DecNumber;
  123.       *array++ = nsdcmdentry->nce_HexNumber;
  124.       *array++ = nsdcmdentry->nce_CmdName;
  125.       *array   = NULL;
  126.    } else {
  127.       *array++ = ESC "bNumber (dec)";
  128.       *array++ = ESC "bNumber (hex)";
  129.       *array++ = ESC "bName";
  130.       *array   = NULL;
  131.    }
  132.    return(0);
  133. }
  134.  
  135. struct Hook nsdcmdentry_dsphook = {
  136.  {NULL, NULL},
  137.  (ULONG (* )())nsdcmdentry_dspfunc,
  138.  NULL, NULL
  139. };
  140.  
  141. __asm __saveds LONG nsdcmdentry_cmpfunc(register __a1 struct NSDCmdEntry *nsdcmdentry1, register __a2 struct NSDCmdEntry *nsdcmdentry2)
  142. {
  143.     return nsdcmdentry1->nce_Number - nsdcmdentry2->nce_Number;
  144. }
  145.  
  146. struct Hook nsdcmdentry_cmphook = {
  147.  {NULL, NULL},
  148.  (ULONG (* )())nsdcmdentry_cmpfunc,
  149.  NULL, NULL
  150. };
  151.  
  152. int TestResource (struct Library *lib) {
  153.    char  *name;
  154.  
  155.    name = lib->lib_Node.ln_Name;
  156.  
  157.    if ((stricmp (name, FSRNAME)) && (stricmp (name, CARDRESNAME)) && \
  158.        (stricmp (name, KEYMAPRESNAME))) {
  159.       return (TRUE);
  160.    } else {
  161.       return (FALSE);
  162.    }
  163. }
  164.  
  165. LONG NSDQuery( UBYTE *dev,
  166.                ULONG unit,
  167.                struct NSDeviceQueryResult *nqr )
  168. {
  169.     LONG result = IOERR_OPENFAIL;
  170.     struct MsgPort *mp;
  171.  
  172.     if (mp = CreateMsgPort()) {
  173.         struct IOStdReq *io;
  174.  
  175.         if (io = CreateIORequest(mp, sizeof(struct IOStdReq) + 128)) {
  176.             if (strcmp(AHINAME, dev) == 0) {
  177.                 ((struct AHIRequest *)io)->ahir_Version = 4;
  178.             }
  179.  
  180.             if (OpenDevice(dev, unit, io, 0) == 0) {
  181.                 io->io_Command = NSCMD_DEVICEQUERY;
  182.                 io->io_Data = nqr;
  183.                 io->io_Length = sizeof(struct NSDeviceQueryResult);
  184.                 result = DoIO(io);
  185.  
  186.                 CloseDevice(io);
  187.             }
  188.  
  189.             DeleteIORequest(io);
  190.         }
  191.  
  192.         DeleteMsgPort(mp);
  193.     }
  194.  
  195.     return result;
  196. }
  197.  
  198. UBYTE *NSDTypeToCmdName( ULONG nsdType,
  199.                          UWORD cmd )
  200. {
  201.     UBYTE *result;
  202.  
  203.     switch (cmd) {
  204.         case CMD_INVALID      : result = "CMD_INVALID"; break;
  205.         case CMD_RESET        : result = "CMD_RESET";   break;
  206.         case CMD_READ         : result = "CMD_READ";    break;
  207.         case CMD_WRITE        : result = "CMD_WRITE";   break;
  208.         case CMD_UPDATE       : result = "CMD_UPDATE";  break;
  209.         case CMD_CLEAR        : result = "CMD_CLEAR";   break;
  210.         case CMD_STOP         : result = "CMD_STOP";    break;
  211.         case CMD_START        : result = "CMD_START";   break;
  212.         case CMD_FLUSH        : result = "CMD_FLUSH";   break;
  213.         case NSCMD_DEVICEQUERY: result = "NSCMD_DEVICEQUERY"; break;
  214.         default               : result = "<unknown>";   break;
  215.     }
  216.  
  217.     switch (nsdType) {
  218.         case NSDEVTYPE_GAMEPORT:
  219.             switch (cmd) {
  220.                 case GPD_READEVENT : result = "GPD_READEVENT";  break;
  221.                 case GPD_ASKCTYPE  : result = "GPD_ASKCTYPE";   break;
  222.                 case GPD_SETCTYPE  : result = "GPD_SETCTYPE";   break;
  223.                 case GPD_ASKTRIGGER: result = "GPD_ASKTRIGGER"; break;
  224.                 case GPD_SETTRIGGER: result = "GPD_SETTRIGGER"; break;
  225.             }
  226.             break;
  227.  
  228.         case NSDEVTYPE_TIMER:
  229.             switch (cmd) {
  230.                 case TR_ADDREQUEST: result = "TR_ADDREQUEST"; break;
  231.                 case TR_GETSYSTIME: result = "TR_GETSYSTIME"; break;
  232.                 case TR_SETSYSTIME: result = "TR_SETSYSTIME"; break;
  233.             }
  234.             break;
  235.  
  236.         case NSDEVTYPE_KEYBOARD:
  237.             switch (cmd) {
  238.                 case KBD_READEVENT       : result = "KBD_READEVENT";        break;
  239.                 case KBD_READMATRIX      : result = "KBD_READMATRIX";       break;
  240.                 case KBD_ADDRESETHANDLER : result = "KBD_ADDRESETHANDLER";  break;
  241.                 case KBD_REMRESETHANDLER : result = "KBD_REMRESETHANDLER";  break;
  242.                 case KBD_RESETHANDLERDONE: result = "KBD_RESETHANDLERDONE"; break;
  243.             }
  244.             break;
  245.  
  246.         case NSDEVTYPE_INPUT:
  247.             switch (cmd) {
  248.                 case IND_ADDHANDLER: result = "IND_ADDHANDLER"; break;
  249.                 case IND_REMHANDLER: result = "IND_REMHANDLER"; break;
  250.                 case IND_WRITEEVENT: result = "IND_WRITEEVENT"; break;
  251.                 case IND_SETTHRESH : result = "IND_SETTHRESH";  break;
  252.                 case IND_SETPERIOD : result = "IND_SETPERIOD";  break;
  253.                 case IND_SETMPORT  : result = "IND_SETMPORT";   break;
  254.                 case IND_SETMTYPE  : result = "IND_SETMTYPE";   break;
  255.                 case IND_SETMTRIG  : result = "IND_SETMTRIG";   break;
  256.             }
  257.             break;
  258.  
  259.         case NSDEVTYPE_TRACKDISK:
  260.             switch (cmd) {
  261.                 case TD_MOTOR          : result = "TD_MOTOR";           break;
  262.                 case TD_SEEK           : result = "TD_SEEK";            break;
  263.                 case TD_FORMAT         : result = "TD_FORMAT";          break;
  264.                 case TD_REMOVE         : result = "TD_REMOVE";          break;
  265.                 case TD_CHANGENUM      : result = "TD_CHANGENUM";       break;
  266.                 case TD_CHANGESTATE    : result = "TD_CHANGESTATE";     break;
  267.                 case TD_PROTSTATUS     : result = "TD_PROTSTATUS";      break;
  268.                 case TD_RAWREAD        : result = "TD_RAWREAD";         break;
  269.                 case TD_RAWWRITE       : result = "TD_RAWWRITE";        break;
  270.                 case TD_GETDRIVETYPE   : result = "TD_GETDRIVETYPE";    break;
  271.                 case TD_GETNUMTRACKS   : result = "TD_GETNUMTRACKS";    break;
  272.                 case TD_ADDCHANGEINT   : result = "TD_ADDCHANGEINT";    break;
  273.                 case TD_REMCHANGEINT   : result = "TD_REMCHANGEINT";    break;
  274.                 case TD_GETGEOMETRY    : result = "TD_GETGEOMETRY";     break;
  275.                 case TD_EJECT          : result = "TD_EJECT";           break;
  276.                 case HD_SCSICMD        : result = "HD_SCSICMD";         break;
  277.                 case ETD_WRITE         : result = "ETD_WRITE";          break;
  278.                 case ETD_READ          : result = "ETD_READ";           break;
  279.                 case ETD_MOTOR         : result = "ETD_MOTOR";          break;
  280.                 case ETD_SEEK          : result = "ETD_SEEK";           break;
  281.                 case ETD_FORMAT        : result = "ETD_FORMAT";         break;
  282.                 case ETD_UPDATE        : result = "ETD_UPDATE";         break;
  283.                 case ETD_CLEAR         : result = "ETD_CLEAR";          break;
  284.                 case ETD_RAWREAD       : result = "ETD_RAWREAD";        break;
  285.                 case ETD_RAWWRITE      : result = "ETD_RAWWRITE";       break;
  286.                 case NSCMD_TD_READ64   : result = "NSCMD_TD_READ64";    break;
  287.                 case NSCMD_TD_WRITE64  : result = "NSCMD_TD_WRITE64";   break;
  288.                 case NSCMD_TD_SEEK64   : result = "NSCMD_TD_SEEK64";    break;
  289.                 case NSCMD_TD_FORMAT64 : result = "NSCMD_TD_FORMAT64";  break;
  290.                 case NSCMD_ETD_READ64  : result = "NSCMD_ETD_READ64";   break;
  291.                 case NSCMD_ETD_WRITE64 : result = "NSCMD_ETD_WRITE64";  break;
  292.                 case NSCMD_ETD_SEEK64  : result = "NSCMD_ETD_SEEK64";   break;
  293.                 case NSCMD_ETD_FORMAT64: result = "NSCMD_ETD_FORMAT64"; break;
  294.                 case CD_INFO           : result = "CD_INFO";            break;
  295.                 case CD_CONFIG         : result = "CD_CONFIG";          break;
  296.                 case CD_TOCMSF         : result = "CD_TOCMSF";          break;
  297.                 case CD_TOCLSN         : result = "CD_TOCLSN";          break;
  298.                 case CD_READXL         : result = "CD_READXL";          break;
  299.                 case CD_PLAYTRACK      : result = "CD_PLAYTRACK";       break;
  300.                 case CD_PLAYMSF        : result = "CD_PLAYMSF";         break;
  301.                 case CD_PLAYLSN        : result = "CD_PLAYLSN";         break;
  302.                 case CD_PAUSE          : result = "CD_PAUSE";           break;
  303.                 case CD_SEARCH         : result = "CD_SEARCH";          break;
  304.                 case CD_QCODEMSF       : result = "CD_QCODEMSF";        break;
  305.                 case CD_QCODELSN       : result = "CD_QCODELSN";        break;
  306.                 case CD_ATTENUATE      : result = "CD_ATTENUATE";       break;
  307.                 case CD_ADDFRAMEINT    : result = "CD_ADDFRAMEINT";     break;
  308.                 case CD_REMFRAMEINT    : result = "CD_REMFRAMEINT";     break;
  309.             }
  310.             break;
  311.  
  312.         case NSDEVTYPE_CONSOLE:
  313.             switch (cmd) {
  314.                 case CD_ASKKEYMAP       : result = "CD_ASKKEYMAP";        break;
  315.                 case CD_SETKEYMAP       : result = "CD_SETKEYMAP";        break;
  316.                 case CD_ASKDEFAULTKEYMAP: result = "CD_ASKDEFAULTKEYMAP"; break;
  317.                 case CD_SETDEFAULTKEYMAP: result = "CD_SETDEFAULTKEYMAP"; break;
  318.             }
  319.             break;
  320.  
  321.         case NSDEVTYPE_SANA2:
  322.             switch (cmd) {
  323.                 case S2_DEVICEQUERY          : result = "S2_DEVICEQUERY";           break;
  324.                 case S2_GETSTATIONADDRESS    : result = "S2_GETSTATIONADDRESS";     break;
  325.                 case S2_CONFIGINTERFACE      : result = "S2_CONFIGINTERFACE";       break;
  326.                 case S2_ADDMULTICASTADDRESS  : result = "S2_ADDMULTICASTADDRESS";   break;
  327.                 case S2_DELMULTICASTADDRESS  : result = "S2_DELMULTICASTADDRESS";   break;
  328.                 case S2_MULTICAST            : result = "S2_MULTICAST";             break;
  329.                 case S2_BROADCAST            : result = "S2_BROADCAST";             break;
  330.                 case S2_TRACKTYPE            : result = "S2_TRACKTYPE";             break;
  331.                 case S2_UNTRACKTYPE          : result = "S2_UNTRACKTYPE";           break;
  332.                 case S2_GETTYPESTATS         : result = "S2_GETTYPESTATS";          break;
  333.                 case S2_GETSPECIALSTATS      : result = "S2_GETSPECIALSTATS";       break;
  334.                 case S2_GETGLOBALSTATS       : result = "S2_GETGLOBALSTATS";        break;
  335.                 case S2_ONEVENT              : result = "S2_ONEVENT";               break;
  336.                 case S2_READORPHAN           : result = "S2_READORPHAN";            break;
  337.                 case S2_ONLINE               : result = "S2_ONLINE";                break;
  338.                 case S2_OFFLINE              : result = "S2_OFFLINE";               break;
  339.                 case 0xc000                  : result = "S2_ADDMULTICASTADDRESSES"; break;
  340.                 case 0xc001                  : result = "S2_DELMULTICASTADDRESSES"; break;
  341.             }
  342.             break;
  343.  
  344.         case NSDEVTYPE_AUDIO:
  345.             switch (cmd) {
  346.                 case ADCMD_FREE     : result = "ADCMD_FREE";      break;
  347.                 case ADCMD_SETPREC  : result = "ADCMD_SETPREC";   break;
  348.                 case ADCMD_FINISH   : result = "ADCMD_FINISH";    break;
  349.                 case ADCMD_PERVOL   : result = "ADCMD_PERVOL";    break;
  350.                 case ADCMD_LOCK     : result = "ADCMD_LOCK";      break;
  351.                 case ADCMD_WAITCYCLE: result = "ADCMD_WAITCYCLE"; break;
  352.                 case ADCMD_ALLOCATE : result = "ADCMD_ALLOCATE";  break;
  353.             }
  354.             break;
  355.  
  356.         case NSDEVTYPE_CLIPBOARD:
  357.             switch (cmd) {
  358.                 case CBD_POST          : result = "CBD_POST";           break;
  359.                 case CBD_CURRENTREADID : result = "CBD_CURRENTREADID";  break;
  360.                 case CBD_CURRENTWRITEID: result = "CBD_CURRENTWRITEID"; break;
  361.                 case CBD_CHANGEHOOK    : result = "CBD_CHANGEHOOK";     break;
  362.             }
  363.             break;
  364.  
  365.         case NSDEVTYPE_PRINTER:
  366.             switch (cmd) {
  367.                 case PRD_RAWWRITE     : result = "PRD_RAWWRITE";      break;
  368.                 case PRD_PRTCOMMAND   : result = "PRD_PRTCOMMAND";    break;
  369.                 case PRD_DUMPRPORT    : result = "PRD_DUMPRPORT";     break;
  370.                 case PRD_QUERY        : result = "PRD_QUERY";         break;
  371.                 case PRD_RESETPREFS   : result = "PRD_RESETPREFS";    break;
  372.                 case PRD_LOADPREFS    : result = "PRD_LOADPREFS";     break;
  373.                 case PRD_USEPREFS     : result = "PRD_USEPREFS";      break;
  374.                 case PRD_SAVEPREFS    : result = "PRD_SAVEPREFS";     break;
  375.                 case PRD_READPREFS    : result = "PRD_READPREFS";     break;
  376.                 case PRD_WRITEPREFS   : result = "PRD_WRITEPREFS";    break;
  377.                 case PRD_EDITPREFS    : result = "PRD_EDITPREFS";     break;
  378.                 case PRD_SETERRHOOK   : result = "PRD_SETERRHOOK";    break;
  379.                 case PRD_DUMPRPORTTAGS: result = "PRD_DUMPRPORTTAGS"; break;
  380.             }
  381.             break;
  382.  
  383.         case NSDEVTYPE_SERIAL:
  384.             switch (cmd) {
  385.                 case SDCMD_QUERY    : result = "SDCMD_QUERY";         break;
  386.                 case SDCMD_BREAK    : result = "SDCMD_BREAK";         break;
  387.                 case SDCMD_SETPARAMS: result = "SDCMD_SETPARAMS";     break;
  388.                 case CMD_NONSTD + 7 : result = "SIOCMD_SETCTRLLINES"; break;
  389.             }
  390.             break;
  391.  
  392.         case NSDEVTYPE_PARALLEL:
  393.             switch (cmd) {
  394.                 case PDCMD_QUERY    : result = "PDCMD_QUERY";     break;
  395.                 case PDCMD_SETPARAMS: result = "PDCMD_SETPARAMS"; break;
  396.             }
  397.             break;
  398.     }
  399.  
  400.     return result;
  401. }
  402.  
  403. static struct FctEntry {
  404.    struct FctEntry *fe_next;
  405.    char fe_address[16];
  406.    char fe_offsetdec[8];
  407.    char fe_offsethex[8];
  408. //*UHEX*   char fe_offsetuns[8];
  409.    char fe_name[52];
  410. };
  411.  
  412. __asm __saveds LONG lfctlist_dspfunc(register __a2 char **array, register __a1 struct FctEntry *entry, register __a0 struct Hook *hook)
  413. {
  414.    if (entry) {
  415.       *array++ = entry->fe_offsetdec;
  416.       *array++ = entry->fe_offsethex;
  417. //*UHEX*      *array++ = entry->fe_offsetuns;
  418.       *array++ = entry->fe_address;
  419.       *array   = entry->fe_name;
  420.    } else {
  421.       *array++ = ESC "bOffset";
  422.       *array++ = ESC "bHex";
  423. //*UHEX*      *array++ = ESC "bU-Hex";
  424.       *array++ = ESC "bAddress";
  425.       *array   = ESC "bName";
  426.    }
  427.    return(0);
  428. }
  429.  
  430. struct Hook lfctlist_dsphook = {
  431.  {NULL, NULL},
  432.  (ULONG (* )())lfctlist_dspfunc,
  433.  NULL, NULL
  434. };
  435.  
  436. void GetLDRFctList (struct Library *lib, char mode) {
  437.    struct   WinFree  *ptr;
  438.    unsigned char     *title = "FUNCTIONS: ";
  439.    APTR     lfctlist;
  440.    ULONG    offset, max;
  441.    struct   FctEntry *entry;
  442.    APTR     fctadr;
  443.    BOOL     getfct = (IdentifyBase!=NULL);
  444.    STRPTR   name;
  445.    APTR     pool = NULL;
  446.  
  447.    switch (mode) {
  448.       case 'L': pool = LibPool; break;
  449.       case 'D': pool = DevPool; break;
  450.       case 'R': pool = ResPool; break;
  451.    }
  452.  
  453.    if (ptr = AllocWinFree()) {
  454.       ptr->wf_Window = (APTR) WindowObject,
  455.       MUIA_HelpNode, "Functions",
  456.       MUIA_Window_ID, MakeDetailID('.','L','F','T'),
  457.       WindowContents, VGroup,
  458.          Child, lfctlist = ListviewObject,
  459.             MUIA_Listview_Input, FALSE,
  460.             MUIA_Listview_List, ListObject,
  461.                ReadListFrame,
  462.                MUIA_List_Title, TRUE,
  463.                MUIA_List_Format, "DELTA=8 P=\33r, DELTA=8 P=\33r, DELTA=8,",
  464. //*UHEX*               MUIA_List_Format, "DELTA=8 P=\33r, P=\33r, DELTA=8 P=\33r, DELTA=8,",
  465.                MUIA_List_DisplayHook, &lfctlist_dsphook,
  466.             End,
  467.             MUIA_CycleChain, TRUE,
  468.          End,
  469.       End, End;
  470.  
  471.       if (ptr->wf_Window) {
  472.          ptr->wf_ActiveObject = lfctlist;
  473.  
  474.          name = lib->lib_Node.ln_Name;
  475.  
  476.          if( mode!='R' || (
  477.                stricmp(name, FSRNAME)
  478.             && stricmp(name, CARDRESNAME)
  479.             && stricmp(name, KEYMAPRESNAME))) {
  480.  
  481.             if(!stricmp(name, CIAANAME) || !stricmp(name, CIABNAME))
  482.               name = "cia.resource";
  483.  
  484.             max = lib->lib_NegSize;
  485.  
  486.             set(lfctlist,MUIA_List_Quiet,TRUE);
  487.  
  488.             for(offset=6; offset <= max; offset+=6) {
  489.               if(entry = tbAllocPooled(pool, sizeof(struct FctEntry))) {
  490.  
  491.                  if(*(WORD *)(((UBYTE*)lib) - offset) == 0x4ef9) {
  492.                     fctadr = (APTR) *(LONG *)(((UBYTE *)lib) - offset + 2);
  493.                     if (points2ram(fctadr)) {
  494.                        _sprintf (entry->fe_address, HELL "$%08lx" DUNKEL, fctadr);
  495.                     } else {
  496.                        _sprintf (entry->fe_address, "$%08lx", fctadr);
  497.                     }
  498.                  } else {
  499.                     strcpy(entry->fe_address, "<no jmp>");
  500.                  }
  501.  
  502.                  _sprintf (entry->fe_offsetdec, "-%ld"  , offset);
  503.                  _sprintf (entry->fe_offsethex, "-%04lx" , offset);
  504. //*UHEX*                 _sprintf (entry->fe_offsetuns, "%04X" , 0x10000-offset);
  505.  
  506.                  if(offset<42 && (mode=='D' || (mode=='L' && offset<30))) {
  507.  
  508.                    STRPTR help;
  509.                    switch(offset) {
  510.                       case  6: help = "Open"   ; break;
  511.                       case 12: help = "Close"  ; break;
  512.                       case 18: help = "Expunge"; break;
  513.                       case 24: help = "Null"   ; break;
  514.                       case 30: help = "AbortIO"; break;
  515.                       case 36: help = "BeginIO"; break;
  516.                       default: help = ""; break;
  517.                    }
  518.                    strcpy(entry->fe_name,help);
  519.  
  520.                  } else if(getfct) {
  521.                     switch(IdFunctionTags(name,offset,IDTAG_FuncNameStr,entry->fe_name,TAG_DONE)) {
  522.                       case IDERR_NOFD:
  523.                       case IDERR_NOMEM:
  524.                          getfct = FALSE;
  525.                          break;
  526.  
  527.                       case IDERR_OFFSET:
  528.                          strcpy(entry->fe_name,"---");
  529.                          break;
  530.                     }
  531.                  }
  532.  
  533.                  InsertBottomEntry (lfctlist, (APTR *) &entry);
  534.  
  535.               }
  536.             }
  537.             set(lfctlist,MUIA_List_Quiet,FALSE);
  538.          }
  539.  
  540.          HandleWindowOpen (ptr, title, lib->lib_Node.ln_Name);
  541.          HandleWindowClose (ptr);
  542.       }
  543.    }
  544. }
  545.  
  546.  
  547. void GetLDRMore (struct Library *lib, char *title, char *helpnode) {
  548.    unsigned char           rpct[4];
  549.    struct   WinFree        *ptr;
  550.    int      rpc, i;
  551.  
  552.    APTR LibMainGroup;
  553.    APTR libmoretext0,libmoretext1,libmoretext2a,libmoretext2b,libmoretext3,libmoretext4;
  554.    APTR LibMoreAdd1,LibMoreGroup1,LibMoreAdd2,LibMoreGroup2;
  555.    APTR FSList, DevMoreAdd1, DevMoreAdd2, DevMoreAdd3, DevMoreText1, NSDCmdList;
  556.  
  557.    UBYTE drflags[]   = {DRF_ALLOC0,DRF_ALLOC1,DRF_ALLOC2,DRF_ALLOC3,DRF_ACTIVE,0};
  558.  
  559.    char  *drflagstext[] = {"ALLOC0","ALLOC1","ALLOC2",
  560.                            "ALLOC3","ACTIVE"};
  561.  
  562.    TestResource (lib);
  563.  
  564.    if (ptr = AllocWinFree()) {
  565.       if (! stricmp (lib->lib_Node.ln_Name, FSRNAME)) {
  566.  
  567.          ptr->wf_Window = (APTR) WindowObject,
  568.  
  569.          MUIA_HelpNode, helpnode,
  570.          MUIA_Window_ID, MakeDetailID('.','F','S','Y'),
  571.          WindowContents, VGroup,
  572.             Child, HGroup,
  573.                Child, VGroup, MUIA_Group_SameWidth, TRUE,
  574.                   Child, MyLabel2 ("Name:"),
  575.                   Child, MyLabel2 ("Address:\nPri:"),
  576.                   Child, MyLabel2 ("fsr_Creator:"),
  577.                End,
  578.                Child, VGroup,
  579.                   Child, MyTextObject3 (FSRNAME),
  580.                   Child, HGroup,
  581.                      Child, libmoretext1 = MyTextObject(),
  582.                      Child, MyLabel ("Type:"),
  583.                      Child, libmoretext2b = MyTextObject(),
  584.                   End,
  585.                   Child, libmoretext3 = MyTextObject(),
  586.                End,
  587.             End,
  588.             Child, HGroup,
  589.                Child, MyHSpace(0),
  590.                Child, MyLabel2 ("fsr_FileSysEntries:"),
  591.                Child, MyHSpace(0),
  592.             End,
  593.             Child, FSList = ListviewObject,
  594.                MUIA_Listview_Input, FALSE,
  595.                MUIA_Listview_List, ListObject,
  596.                   ReadListFrame,
  597.                   MUIA_List_Title, TRUE,
  598.                   MUIA_List_Format, "DELTA=8 P=\33c, DELTA=8, DELTA=8 P=\33c, DELTA=8",
  599.                   MUIA_List_DisplayHook, &fsentry_dsphook,
  600.                   MUIA_List_CompareHook, &fsentry_cmphook,
  601.                End,
  602.                MUIA_CycleChain, TRUE,
  603.             End,
  604.          End, End;
  605.  
  606.          if (ptr->wf_Window) {
  607.             struct FileSysResource *fsr;
  608.             struct FileSysEntry *fse;
  609.             struct FSEntry *entry;
  610.  
  611.             MySetContents (libmoretext1, ESC "c$%08lx\n%ld", lib, lib->lib_Node.ln_Pri);
  612.             MySetContents (libmoretext2b, ESC "c %s ", GetNodeType (lib->lib_Node.ln_Type));
  613.  
  614.             strcpy (tmpstr, ((struct FileSysResource *) lib)->fsr_Creator);
  615.             healstring (tmpstr);
  616.             set (libmoretext3, MUIA_Text_Contents, tmpstr);
  617.  
  618.             HandleWindowOpen (ptr, title, FSRNAME);
  619.             HandleWindowClose (ptr);
  620.  
  621.             set(FSList,MUIA_List_Quiet, TRUE);
  622.  
  623.             fsr = (struct FileSysResource *)lib;
  624.             for (fse = (struct FileSysEntry *)fsr->fsr_FileSysEntries.lh_Head; fse->fse_Node.ln_Succ; fse = (struct FileSysEntry *)fse->fse_Node.ln_Succ) {
  625.                if (entry = tbAllocPooled(LibPool, sizeof(struct FSEntry))) {
  626.                   strcpy(entry->fs_FileSystem, GetDiskType((LONG *)&fse->fse_DosType));
  627.                   _sprintf(entry->fs_DOSType, "$%08lx", fse->fse_DosType);
  628.                   _sprintf(entry->fs_Version, "%ld.%ld", fse->fse_Version >> 16, fse->fse_Version & 0xffff);
  629.                   strncpy(entry->fs_Creator, nonetest(fse->fse_Node.ln_Name), 63);
  630.                   healstring(entry->fs_Creator);
  631.                   InsertSortedEntry (FSList, (APTR *) &entry);
  632.                }
  633.             }
  634.  
  635.             set(FSList,MUIA_List_Quiet, FALSE);
  636.             set(ptr->wf_Window, MUIA_Window_ActiveObject, FSList);
  637.          }
  638.       } else if ((! stricmp (lib->lib_Node.ln_Name, CARDRESNAME)) || \
  639.                  (! stricmp (lib->lib_Node.ln_Name, KEYMAPRESNAME))) {
  640.          ptr->wf_Window = (APTR) WindowObject,
  641.  
  642.          MUIA_HelpNode, helpnode,
  643.          MUIA_Window_ID, MakeDetailID('.','L','I','B'),
  644.          WindowContents, HGroup,
  645.             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  646.                Child, MyLabel2 ("Name:"),
  647.                Child, MyLabel2 ("Address:\nPri:"),
  648.             End,
  649.             Child, VGroup,
  650.                Child, MyTextObject3 (lib->lib_Node.ln_Name),
  651.                Child, HGroup,
  652.                   Child, libmoretext1 = MyTextObject(),
  653.                   Child, MyLabel ("Type:"),
  654.                   Child, libmoretext2b = MyTextObject(), 
  655.                End,
  656.             End,
  657.          End, End;
  658.  
  659.          if (ptr->wf_Window) {
  660.             MySetContents (libmoretext1, ESC "c$%08lx\n%ld", lib, lib->lib_Node.ln_Pri);
  661.             MySetContents (libmoretext2b, ESC "c %s ", GetNodeType (lib->lib_Node.ln_Type));
  662.  
  663.             HandleWindowOpen (ptr, title, lib->lib_Node.ln_Name);
  664.             HandleWindowClose (ptr);
  665.          }
  666.       } else {
  667.          ptr->wf_Window = (APTR) WindowObject,
  668.  
  669.          MUIA_HelpNode, helpnode,
  670.          MUIA_Window_ID, MakeDetailID('.','L','I','B'),
  671.          WindowContents, LibMainGroup = VGroup,
  672.             Child, HGroup,
  673.                Child, LibMoreGroup1 = VGroup, MUIA_Group_SameWidth, TRUE,
  674.                   Child, MyLabel2 ("Name:"),
  675.                   Child, MyVSpace(0),
  676.                   Child, MyLabel2 ("Address:\nPri:\nType:\nVersion:\nOpenCnt:"),
  677.                   Child, MyVSpace(0),
  678.                   Child, MyLabel2 ("IdString:"),
  679.                End,
  680.                Child, LibMoreGroup2 = VGroup,
  681.                   Child, libmoretext0 = MyTextObject(),
  682.                   Child, HGroup,
  683.                      Child, libmoretext1 = MyTextObject(),
  684.                      Child, VGroup,
  685.                         Child, MyLabel ("Flags:"),
  686.                         Child, MyLabel ("NegSize:\nPosSize:\nSum:\nRamPtrCnt:"),
  687.                      End,
  688.                      Child, VGroup,
  689.                         Child, libmoretext2a = KeyButtonF ('b', lib->lib_Flags),
  690.                         Child, libmoretext2b = MyTextObject(),
  691.                      End,
  692.                   End,
  693.                   Child, libmoretext3 = MyTextObject(),
  694.                End,
  695.             End,
  696.          End, End;
  697.  
  698.          if (ptr->wf_Window) {
  699.             if ((rpc = GetRamPointerCount (lib)) == (lib->lib_NegSize / 6)) {
  700.                strcpy (rpct, "***");
  701.             } else {
  702.                _sprintf (rpct, "%ld", rpc);
  703.             }
  704.             MySetContents (libmoretext1, ESC "c$%08lx\n%ld\n%s\n%ld.%ld\n%ld", lib, lib->lib_Node.ln_Pri, GetNodeType (lib->lib_Node.ln_Type), lib->lib_Version, lib->lib_Revision, lib->lib_OpenCnt);
  705.             MySetContents (libmoretext2b, ESC "c%ld\n%ld\n$%08lx\n%s", lib->lib_NegSize, lib->lib_PosSize, lib->lib_Sum, rpct);
  706.  
  707.             if (! stricmp (lib->lib_Node.ln_Name, DISKNAME)) {
  708.                Child, LibMoreAdd1 = VGroup, MUIA_Group_SameWidth, TRUE,
  709.                   Child, MyLabel2 ("dr_Current:"),
  710.                   Child, MyLabel2 ("dr_CurrTask:"),
  711.                End;
  712.  
  713.                Child, LibMoreAdd2 = VGroup,
  714.                   Child, libmoretext4 = MyTextObject(),
  715.                   Child, MyTextObject3 (GetTaskName (((struct DiscResource *) lib)->dr_CurrTask)),
  716.                End;
  717.  
  718.                tmpstr[0] = '\0';
  719.                i = 0;
  720.                while (drflags[i]) {
  721.                   if (((struct DiscResource *) lib)->dr_Flags & drflags[i]) {
  722.                      if (strlen (tmpstr))
  723.                         strcat (tmpstr, ", ");
  724.                      strcat (tmpstr, drflagstext[i]);
  725.                   }
  726.                   i++;
  727.                }
  728.                set (libmoretext4, MUIA_Text_Contents, nonetest (tmpstr));
  729.                DoMethod (LibMoreGroup1,OM_ADDMEMBER,LibMoreAdd1);
  730.                DoMethod (LibMoreGroup2,OM_ADDMEMBER,LibMoreAdd2);
  731.             }
  732.  
  733.             if (strstr(lib->lib_Node.ln_Name, ".device") != NULL) {
  734.                ULONG unit;
  735.                UBYTE nsdType[64];
  736.  
  737.                Child, DevMoreAdd1 = VGroup, MUIA_Group_SameWidth, TRUE,
  738.                   Child, MyLabel2 ("NSDType:"),
  739.                End;
  740.  
  741.                Child, DevMoreAdd2 = VGroup,
  742.                   Child, DevMoreText1 = MyTextObject(),
  743.                End;
  744.  
  745.                Child, DevMoreAdd3 = VGroup,
  746.                   Child, HGroup,
  747.                      Child, MyHSpace(0),
  748.                      Child, MyLabel2 ("Supported commands:"),
  749.                      Child, MyHSpace(0),
  750.                   End,
  751.                   Child, NSDCmdList = ListviewObject,
  752.                      MUIA_Listview_Input, FALSE,
  753.                      MUIA_Listview_List, ListObject,
  754.                         ReadListFrame,
  755.                         MUIA_List_Title, TRUE,
  756.                         MUIA_List_Format, "DELTA=8 P=\33c, DELTA=8 P=\33c, DELTA=8",
  757.                         MUIA_List_DisplayHook, &nsdcmdentry_dsphook,
  758.                         MUIA_List_CompareHook, &nsdcmdentry_cmphook,
  759.                      End,
  760.                      MUIA_CycleChain, TRUE,
  761.                   End,
  762.                End;
  763.  
  764.                strcpy(nsdType, "unknown (device could not be openend)");
  765.  
  766.                for (unit = 0; unit < 16; unit++) {
  767.                   struct NSDeviceQueryResult nqr;
  768.                   LONG ioErr;
  769.  
  770.                   if ((ioErr = NSDQuery(lib->lib_Node.ln_Name, unit, &nqr)) == 0) {
  771.                      UWORD *cmds;
  772.                      struct NSDCmdEntry *entry;
  773.  
  774.                      set(NSDCmdList, MUIA_List_Quiet, TRUE);
  775.  
  776.                      cmds = nqr.SupportedCommands;
  777.                      while (*cmds) {
  778.                         if (entry = tbAllocPooled(LibPool, sizeof(struct NSDCmdEntry))) {
  779.                            entry->nce_Number = *cmds;
  780.                            _sprintf(entry->nce_DecNumber, "%ld", *cmds);
  781.                            _sprintf(entry->nce_HexNumber, "$%04lx", *cmds);
  782.                            strcpy(entry->nce_CmdName, NSDTypeToCmdName(nqr.DeviceType, *cmds));
  783.                            InsertSortedEntry (NSDCmdList, (APTR *) &entry);
  784.                         }
  785.                         cmds++;
  786.                      }
  787.  
  788.                      set(NSDCmdList, MUIA_List_Quiet, FALSE);
  789.  
  790.                      switch (nqr.DeviceType) {
  791.                         case NSDEVTYPE_GAMEPORT:  strcpy(nsdType, "gameport");  break;
  792.                         case NSDEVTYPE_TIMER:     strcpy(nsdType, "timer");     break;
  793.                         case NSDEVTYPE_KEYBOARD:  strcpy(nsdType, "keyboard");  break;
  794.                         case NSDEVTYPE_INPUT:     strcpy(nsdType, "input");     break;
  795.                         case NSDEVTYPE_TRACKDISK: strcpy(nsdType, "trackdisk"); break;
  796.                         case NSDEVTYPE_CONSOLE:   strcpy(nsdType, "console");   break;
  797.                         case NSDEVTYPE_SANA2:     strcpy(nsdType, "sana2");     break;
  798.                         case NSDEVTYPE_AUDIO:     strcpy(nsdType, "audio");     break;
  799.                         case NSDEVTYPE_CLIPBOARD: strcpy(nsdType, "clipboard"); break;
  800.                         case NSDEVTYPE_PRINTER:   strcpy(nsdType, "printer");   break;
  801.                         case NSDEVTYPE_SERIAL:    strcpy(nsdType, "serial");    break;
  802.                         case NSDEVTYPE_PARALLEL:  strcpy(nsdType, "parallel");  break;
  803.                         default: strcpy(nsdType, "unknown"); break;
  804.                      }
  805.  
  806.                      _sprintf(tmpstr2, " (subtype %ld)", nqr.DeviceSubType);
  807.                      strcat(nsdType, tmpstr2);
  808.                      break;
  809.                   } else {
  810.                      switch (ioErr) {
  811.                         default:
  812.                         case IOERR_OPENFAIL: strcpy(nsdType, "unknown (device could not be openend)"); break;
  813.                         case IOERR_NOCMD: strcpy(nsdType, "unknown (device does not support NSD)"); break;
  814.                      }
  815.  
  816.                      if (ioErr == IOERR_NOCMD) break;
  817.                   }
  818.                }
  819.  
  820.                set(DevMoreText1, MUIA_Text_Contents, nsdType);
  821.                set(ptr->wf_Window, MUIA_Window_ActiveObject, NSDCmdList);
  822.  
  823.                DoMethod(LibMoreGroup1, OM_ADDMEMBER, DevMoreAdd1);
  824.                DoMethod(LibMoreGroup2, OM_ADDMEMBER, DevMoreAdd2);
  825.                DoMethod(LibMainGroup, OM_ADDMEMBER, DevMoreAdd3);
  826.             }
  827.  
  828.             HandleFlagsButtonPressed (libmoretext2a, ptr, "(LIBRARY)", "lib_Flags", lib->lib_Flags, (struct LongFlag *) &lib_flags, NULL, 'b');
  829.             HandleWindowOpen (ptr, title, lib->lib_Node.ln_Name);
  830.             MySetContentsHealed (libmoretext0, "%s", lib->lib_Node.ln_Name);
  831.             MySetContentsHealed (libmoretext3, "%s", nonetest (lib->lib_IdString));
  832.             HandleWindowClose (ptr);
  833.          }
  834.       }
  835.    }
  836. }
  837.  
  838. void GetLibMore (struct Library *lib) {
  839.    char *title = "LIBRARY: ";
  840.  
  841.    GetLDRMore (lib, title, LibrariesText);
  842. }
  843.  
  844. void GetDevMore (struct Library *lib) {
  845.    char *title = "DEVICE: ";
  846.  
  847.    GetLDRMore (lib, title, DevicesText);
  848. }
  849.  
  850. void GetResMore (struct Library *lib) {
  851.    char *title = "RESOURCE: ";
  852.  
  853.    GetLDRMore (lib, title, ResourcesText);
  854. }
  855.  
  856. void PrintLDR (APTR list, char type, char *filename) {
  857.    int   i;
  858.    BPTR  handle;
  859.    struct LibEntry *entryp = NULL;
  860.  
  861.    handle = HandlePrintStart (filename);
  862.    if ((handle) && (PrintOneLine (handle, "\n  Address   Pri OpenC RPC Name & Version\n\n"))) {
  863.       if ((type == 'L') && (! WI_Libraries)) {
  864.          FillLDRList ('L', &entryp);
  865.       } else if ((type == 'D') && (! WI_Devices)) {
  866.          FillLDRList ('D', &entryp);
  867.       } else if ((type == 'R') && (! WI_Resources)) {
  868.          FillLDRList ('R', &entryp);
  869.       }
  870. //      if (i) {
  871.          for (i=0;;i++) {
  872.  
  873.             if (((type == 'L') && (WI_Libraries)) \
  874.                || ((type == 'D') && (WI_Devices)) \
  875.                || ((type == 'R') && (WI_Resources))) {
  876.                DoMethod (list,MUIM_List_GetEntry,i,&entryp);
  877.             }
  878.             if (!entryp) break;
  879.  
  880.             _sprintf (tmpstr2, " %s %4s %4s %3s %s %ld.%ld\n", entryp->lib_address, entryp->lib_pri, entryp->lib_ocnt, entryp->lib_rcnt, entryp->lib_name, ((struct Library *) entryp->lib_ptr)->lib_Version, ((struct Library *) entryp->lib_ptr)->lib_Revision);
  881.             if (! (PrintOneLine (handle, tmpstr2)))
  882.                break;
  883.  
  884.             if (((type == 'L') && (! WI_Libraries)) \
  885.                || ((type == 'D') && (! WI_Devices)) \
  886.                || ((type == 'R') && (! WI_Resources))) {
  887.                entryp = entryp->lib_next;
  888.             }
  889.          }
  890. //      }
  891.    }
  892.    HandlePrintStop();
  893. }
  894.  
  895. void PrintLibraries (char *filename) {
  896.    PrintLDR (liblist,'L',filename);
  897. }
  898.  
  899. void PrintDevices (char *filename) {
  900.    PrintLDR (devlist,'D',filename);
  901. }
  902.  
  903. void PrintResources (char *filename) {
  904.    PrintLDR (reslist,'R',filename);
  905. }
  906.  
  907. int FillLDRList (char kind, struct LibEntry **first) {
  908.    struct   Library  *lib = NULL;
  909.    APTR     pool = NULL;
  910.    char     *cmd = NULL;
  911.  
  912.    struct   LibEntry   *libentry,*previous = NULL;
  913.    int      tmp, teststatus;
  914.  
  915.    int libcnt = 0;
  916.    *first = 0;
  917.  
  918.    if (kind == 'L') {
  919.       lib = FIRSTLIBRARY;
  920.       FreeLibraries();
  921.       pool = LibPool = tbCreatePool(MEMF_CLEAR, 4096, 4096);
  922.       cmd = "GetLibList";
  923.    } else if (kind == 'D') {
  924.       lib = FIRSTDEVICE;
  925.       FreeDevices();
  926.       pool = DevPool = tbCreatePool(MEMF_CLEAR, 4096, 4096);
  927.       cmd = "GetDevList";
  928.    } else if (kind == 'R') {
  929.       lib = FIRSTRESOURCE;
  930.       FreeResources();
  931.       pool = ResPool = tbCreatePool(MEMF_CLEAR, 4096, 4096);
  932.       cmd = "GetResList";
  933.    }
  934.  
  935.    if (clientstate) {
  936.       if (SendDaemon (cmd)) {
  937.          while ((libentry = tbAllocPooled(pool, sizeof(struct LibEntry))) \
  938.            && (ReceiveDecodedEntry ((UBYTE *) libentry, sizeof (struct LibEntry)))) {
  939.             IsHex (libentry->lib_address, (long *) &libentry->lib_ptr);
  940.  
  941.             if (! *first)
  942.                *first = libentry;
  943.             if (previous)
  944.                previous->lib_next = libentry;
  945.  
  946.             libcnt++;
  947.             previous = libentry;
  948.          }
  949.       }
  950.    } else {
  951.       while ((lib->lib_Node.ln_Succ != 0) && (libentry = tbAllocPooled(pool, sizeof(struct LibEntry)))) {
  952.          if (! *first)
  953.             *first = libentry;
  954.          if (previous)
  955.             previous->lib_next = libentry;
  956.    
  957.          libentry->lib_ptr = (char *) lib;
  958.          _sprintf (libentry->lib_address, "$%08lx",lib);
  959.          strncpy (libentry->lib_name, lib->lib_Node.ln_Name, 30);
  960.          _sprintf (libentry->lib_pri, "%4ld ", lib->lib_Node.ln_Pri);
  961.          if (strcmp(libentry->lib_name, FSRNAME) == 0 || strcmp(libentry->lib_name, KEYMAPRESNAME) == 0) {
  962.              strcpy(libentry->lib_ver, "---");
  963.          } else {
  964.              _sprintf (libentry->lib_ver, "%ld.%ld ", lib->lib_Version, lib->lib_Revision);
  965.          }
  966.    
  967.          teststatus = TestResource (lib);
  968.    
  969.          if (teststatus) {
  970.             _sprintf (libentry->lib_ocnt, "%3ld ", lib->lib_OpenCnt);
  971.             if ((tmp = GetRamPointerCount(lib)) == (lib->lib_NegSize / 6)) {
  972.                strcpy (libentry->lib_rcnt, "***");
  973.             } else {
  974.                _sprintf (libentry->lib_rcnt, "%3ld", tmp);
  975.             }
  976.          } else {
  977.             strcpy (libentry->lib_ocnt, "--- ");
  978.             strcpy (libentry->lib_rcnt, "---");
  979.          }
  980.          strcpy (libentry->lib_type, GetNodeType (lib->lib_Node.ln_Type));
  981.    
  982.          libcnt++;
  983.          previous = libentry;
  984.          lib = (struct Library *)lib->lib_Node.ln_Succ;
  985.       }
  986.    }
  987.    return (libcnt);
  988. }
  989.  
  990. void FreeLibraries (void)
  991. {
  992.     MyFreePoolStructs(&LibPool, libtext, NULL, liblist);
  993. }
  994.  
  995. void FlushLibraries (void) {
  996.    struct   Library  *lib,*next;
  997.  
  998.    lib = FIRSTLIBRARY;
  999.  
  1000.    while (next = (struct Library *) lib->lib_Node.ln_Succ) {
  1001.       if (! lib->lib_OpenCnt)
  1002.          RemLibrary (lib);
  1003.       lib = next;
  1004.    }
  1005. }
  1006.  
  1007. void FreeDevices (void)
  1008. {
  1009.     MyFreePoolStructs(&DevPool, devtext, NULL, devlist);
  1010. }
  1011.  
  1012. void FlushDevices (void) {
  1013.    struct   Library  *lib,*next;
  1014.  
  1015.    lib = FIRSTDEVICE;
  1016.  
  1017.    while (next = (struct Library *) lib->lib_Node.ln_Succ) {
  1018.       if (! lib->lib_OpenCnt)
  1019.          RemDevice ((struct Device *) lib);
  1020.       lib = next;
  1021.    }
  1022.    
  1023. }
  1024.  
  1025. void FreeResources (void)
  1026. {
  1027.     MyFreePoolStructs(&ResPool, restext, NULL, reslist);
  1028. }
  1029.  
  1030. void ShowLibraries (void)
  1031. {
  1032.     struct LibEntry *lib;
  1033.  
  1034.     ApplicationSleep();
  1035.     set(liblist,MUIA_List_Quiet,TRUE);
  1036.     set(liblist,MUIA_List_CompareHook,liblist_cmphook_ptr);
  1037.     set(BT_LibRemove, MUIA_Disabled, TRUE);
  1038.     set(BT_LibClose, MUIA_Disabled, TRUE);
  1039.     set(BT_LibPriority, MUIA_Disabled, TRUE);
  1040.     set(BT_LibFunctions, MUIA_Disabled, TRUE);
  1041.     set(BT_LibMore, MUIA_Disabled, TRUE);
  1042.  
  1043.     libcnt = FillLDRList ('L', &lib);
  1044.  
  1045.     while (lib) {
  1046.         InsertSortedEntry (liblist, (APTR *) &lib);
  1047.         lib = lib->lib_next;
  1048.     }
  1049.  
  1050.     SetCountText (libcount, libcnt);
  1051.     AwakeApplication();
  1052.     set(liblist,MUIA_List_Quiet,FALSE);
  1053. }
  1054.  
  1055. void ShowDevices (void)
  1056. {
  1057.     struct LibEntry *lib;
  1058.  
  1059.     ApplicationSleep();
  1060.     set(devlist,MUIA_List_Quiet,TRUE);
  1061.     set(devlist,MUIA_List_CompareHook,devlist_cmphook_ptr);
  1062.     set(BT_DevRemove, MUIA_Disabled, TRUE);
  1063.     set(BT_DevPriority, MUIA_Disabled, TRUE);
  1064.     set(BT_DevFunctions, MUIA_Disabled, TRUE);
  1065.     set(BT_DevMore, MUIA_Disabled, TRUE);
  1066.  
  1067.     devcnt = FillLDRList ('D', &lib);
  1068.  
  1069.     while (lib) {
  1070.         InsertSortedEntry (devlist, (APTR *) &lib);
  1071.         lib = lib->lib_next;
  1072.     }
  1073.  
  1074.     SetCountText (devcount, devcnt);
  1075.     AwakeApplication();
  1076.     set(devlist,MUIA_List_Quiet,FALSE);
  1077. }
  1078.  
  1079. void ShowResources (void)
  1080. {
  1081.     struct LibEntry *lib;
  1082.  
  1083.     ApplicationSleep();
  1084.     set(reslist,MUIA_List_Quiet,TRUE);
  1085.     set(reslist,MUIA_List_CompareHook,reslist_cmphook_ptr);
  1086.     set(BT_ResRemove, MUIA_Disabled, TRUE);
  1087.     set(BT_ResPriority, MUIA_Disabled, TRUE);
  1088.     set(BT_ResFunctions, MUIA_Disabled, TRUE);
  1089.     set(BT_ResMore, MUIA_Disabled, TRUE);
  1090.  
  1091.     rescnt = FillLDRList ('R', &lib);
  1092.  
  1093.     while (lib) {
  1094.         InsertSortedEntry (reslist, (APTR *) &lib);
  1095.         lib = lib->lib_next;
  1096.     }
  1097.  
  1098.     SetCountText (rescount, rescnt);
  1099.     AwakeApplication();
  1100.     set(reslist,MUIA_List_Quiet,FALSE);
  1101. }
  1102.  
  1103. void SendLibList (void)
  1104. {
  1105.     struct LibEntry *lib;
  1106.  
  1107.     FillLDRList ('L', &lib);
  1108.  
  1109.     while (lib) {
  1110.         SendEncodedEntry ((UBYTE *) lib, sizeof (struct LibEntry));
  1111.         lib = lib->lib_next;
  1112.     }
  1113.     FreeLibraries ();
  1114. }
  1115.  
  1116. void SendDevList (void)
  1117. {
  1118.     struct LibEntry *lib;
  1119.  
  1120.     FillLDRList ('D', &lib);
  1121.  
  1122.     while (lib) {
  1123.         SendEncodedEntry ((UBYTE *) lib, sizeof (struct LibEntry));
  1124.         lib = lib->lib_next;
  1125.     }
  1126.     FreeDevices ();
  1127. }
  1128.  
  1129. void SendResList (void)
  1130. {
  1131.     struct LibEntry *lib;
  1132.  
  1133.     FillLDRList ('R', &lib);
  1134.  
  1135.     while (lib) {
  1136.         SendEncodedEntry ((UBYTE *) lib, sizeof (struct LibEntry));
  1137.         lib = lib->lib_next;
  1138.     }
  1139.     FreeResources ();
  1140. }
  1141.  
  1142. APTR LibSortList[] = {
  1143.    &list_cmpnormalhook,
  1144.    &list_cmpnamehook,
  1145.    &list_cmpaddresshook,
  1146.    NULL
  1147. };
  1148.  
  1149. static const char *CYA_LibSortText[] = {
  1150.    "priority",
  1151.    "name",
  1152.    "address",
  1153.    NULL
  1154. };
  1155.  
  1156. APTR WI_Libraries, liblist, libtext, libcount, CY_LibSort;
  1157. int  libsortstate = 0;
  1158. APTR BT_LibUpdate, BT_LibPrint, BT_LibPriority, BT_LibClose, BT_LibRemove, BT_LibFunctions, BT_LibMore, BT_LibExit;
  1159.  
  1160. char libraries_title[WINDOWTITLELEN];
  1161.  
  1162. void LibrariesWindow (BOOL state) {
  1163.    if (state) {
  1164.       if (WI_Libraries) {
  1165.          ShowLibraries();
  1166.       } else {
  1167.          WI_Libraries = WindowObject,
  1168.          MUIA_Window_Title, MyGetWindowTitle (libraries_title, "LIBRARIES"),
  1169.          MUIA_HelpNode, LibrariesText,
  1170.          MUIA_Window_ID, MakeListID('L','I','B','S'),
  1171.          WindowContents, VGroup,
  1172.             Child, liblist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33c,COL=4 DELTA=8 P=\33r,COL=5 DELTA=8 P=\33r,COL=6",&liblist_dsphook),
  1173.             Child, MyBelowSortedListview (&libtext, &libcount, &CY_LibSort, CYA_LibSortText, libsortstate),
  1174.             Child, MyVSpace(2),
  1175.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1176.                Child, BT_LibPriority  = KeyButtonA (PriorityText ,ID_LIBPRIORITY),
  1177.                Child, BT_LibClose     = KeyButtonA (CloseText    ,ID_LIBCLOSE),
  1178.                Child, BT_LibRemove    = KeyButtonA (RemoveText   ,ID_LIBREMOVE),
  1179.                Child, BT_LibFunctions = KeyButtonA (FunctionsText,ID_LIBFUNCTIONS),
  1180.             End,
  1181.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1182.                Child, BT_LibUpdate    = KeyButtonA (UpdateText  ,ID_LIBUPDATE),
  1183.                Child, BT_LibPrint     = KeyButtonA (PrintText   ,ID_LIBPRINT),
  1184.                Child, BT_LibMore      = KeyButtonA (MoreText    ,ID_LIBMORE),
  1185.                Child, BT_LibExit      = KeyButtonA (ExitText    ,ID_LIBEXIT),
  1186.             End,
  1187.          End, End;
  1188.  
  1189.          DoMethod (AP_Scout,OM_ADDMEMBER,WI_Libraries);
  1190.          DoMethod (WI_Libraries,MUIM_Window_SetCycleChain,liblist,CY_LibSort,BT_LibUpdate,BT_LibPrint,BT_LibPriority,BT_LibClose,BT_LibRemove,BT_LibFunctions,BT_LibMore,BT_LibExit,NULL);
  1191.          DoMethod (CY_LibSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_LIBSORT);
  1192.  
  1193.          SetCloseRequest (WI_Libraries,ID_LIBEXIT);
  1194.          SetListActive (liblist,ID_LIBLV_ACTIVE);
  1195.          SetListviewDoubleClick (liblist,ID_LIBMORE);
  1196.  
  1197.          ShowLibraries();
  1198.  
  1199.          SetWindowOpen (WI_Libraries,liblist,ID_LIBEXIT);
  1200.       }
  1201.    } else if ((! state) && (WI_Libraries)) {
  1202.       SetWindowClose (WI_Libraries,TRUE);
  1203.  
  1204.       FreeLibraries();
  1205.  
  1206.       DoMethod (AP_Scout,OM_REMMEMBER,WI_Libraries);
  1207.       MUI_DisposeObject (WI_Libraries);
  1208.       WI_Libraries = NULL;
  1209.       liblist = NULL;
  1210.    }
  1211. }
  1212.  
  1213. APTR WI_Devices, devlist, devtext, devcount, CY_DevSort;
  1214. int  devsortstate = 0;
  1215. APTR BT_DevUpdate, BT_DevPrint, BT_DevPriority, BT_DevRemove, BT_DevFunctions, BT_DevMore, BT_DevExit;
  1216.  
  1217. char devices_title[WINDOWTITLELEN];
  1218.  
  1219. void DevicesWindow (BOOL state) {
  1220.    if (state) {
  1221.       if (WI_Devices) {
  1222.          ShowDevices();
  1223.       } else {
  1224.          WI_Devices = WindowObject,
  1225.          MUIA_Window_Title, MyGetWindowTitle (devices_title, "DEVICES"),
  1226.          MUIA_HelpNode, DevicesText,
  1227.          MUIA_Window_ID, MakeListID('D','E','V','S'),
  1228.          WindowContents, VGroup,
  1229.             Child, devlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33c,COL=4 DELTA=8 P=\33r,COL=5 DELTA=8 P=\33r,COL=6",&liblist_dsphook),
  1230.             Child, MyBelowSortedListview (&devtext, &devcount, &CY_DevSort, CYA_LibSortText, devsortstate),
  1231.             Child, MyVSpace(2),
  1232.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1233.                Child, BT_DevPriority  = KeyButtonA (PriorityText ,ID_DEVPRIORITY),
  1234.                Child, BT_DevRemove    = KeyButtonA (RemoveText   ,ID_DEVREMOVE),
  1235.                Child, BT_DevFunctions = KeyButtonA (FunctionsText,ID_DEVFUNCTIONS),
  1236.             End,
  1237.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1238.                Child, BT_DevUpdate    = KeyButtonA (UpdateText   ,ID_DEVUPDATE),
  1239.                Child, BT_DevPrint     = KeyButtonA (PrintText    ,ID_DEVPRINT),
  1240.                Child, BT_DevMore      = KeyButtonA (MoreText     ,ID_DEVMORE),
  1241.                Child, BT_DevExit      = KeyButtonA (ExitText     ,ID_DEVEXIT),
  1242.             End,
  1243.          End, End;
  1244.  
  1245.          DoMethod (AP_Scout,OM_ADDMEMBER,WI_Devices);
  1246.          DoMethod (WI_Devices,MUIM_Window_SetCycleChain,devlist,CY_DevSort,BT_DevUpdate,BT_DevPrint,BT_DevPriority,BT_DevRemove,BT_DevMore,BT_DevFunctions,BT_DevExit,NULL);
  1247.          DoMethod (CY_DevSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_DEVSORT);
  1248.  
  1249.          SetCloseRequest (WI_Devices,ID_DEVEXIT);
  1250.          SetListActive (devlist,ID_DEVLV_ACTIVE);
  1251.          SetListviewDoubleClick (devlist,ID_DEVMORE);
  1252.  
  1253.          ShowDevices();
  1254.  
  1255.          SetWindowOpen (WI_Devices,devlist,ID_DEVEXIT);
  1256.       }
  1257.    } else if ((! state) && (WI_Devices)) {
  1258.       SetWindowClose (WI_Devices,TRUE);
  1259.  
  1260.       FreeDevices();
  1261.  
  1262.       DoMethod (AP_Scout,OM_REMMEMBER,WI_Devices);
  1263.       MUI_DisposeObject (WI_Devices);
  1264.       WI_Devices = NULL;
  1265.       devlist = NULL;
  1266.    }
  1267. }
  1268.  
  1269. APTR WI_Resources, reslist, restext, rescount, CY_ResSort;
  1270. int  ressortstate = 0;
  1271. APTR BT_ResUpdate, BT_ResPrint, BT_ResPriority, BT_ResRemove, BT_ResFunctions, BT_ResMore, BT_ResExit;
  1272.  
  1273. char resources_title[WINDOWTITLELEN];
  1274.  
  1275. void ResourcesWindow (BOOL state) {
  1276.    if (state) {
  1277.       if (WI_Resources) {
  1278.          ShowResources();
  1279.       } else {
  1280.          WI_Resources = WindowObject,
  1281.          MUIA_Window_Title, MyGetWindowTitle (resources_title, "RESOURCES"),
  1282.          MUIA_HelpNode, ResourcesText,
  1283.          MUIA_Window_ID, MakeListID('R','E','S','O'),
  1284.          WindowContents, VGroup,
  1285.             Child, reslist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33c,COL=4 DELTA=8 P=\33r,COL=5 DELTA=8 P=\33r,COL=6",&liblist_dsphook),
  1286.             Child, MyBelowSortedListview (&restext, &rescount, &CY_ResSort, CYA_LibSortText, ressortstate),
  1287.             Child, MyVSpace(2),
  1288.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1289.                Child, BT_ResPriority  = KeyButtonA (PriorityText ,ID_RESPRIORITY),
  1290.                Child, BT_ResRemove    = KeyButtonA (RemoveText   ,ID_RESREMOVE),
  1291.                Child, BT_ResFunctions = KeyButtonA (FunctionsText,ID_RESFUNCTIONS),
  1292.             End,
  1293.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1294.                Child, BT_ResUpdate    = KeyButtonA (UpdateText   ,ID_RESUPDATE),
  1295.                Child, BT_ResPrint     = KeyButtonA (PrintText    ,ID_RESPRINT),
  1296.                Child, BT_ResMore      = KeyButtonA (MoreText     ,ID_RESMORE),
  1297.                Child, BT_ResExit      = KeyButtonA (ExitText     ,ID_RESEXIT),
  1298.             End,
  1299.          End, End;
  1300.  
  1301.          DoMethod (AP_Scout,OM_ADDMEMBER,WI_Resources);
  1302.          DoMethod (WI_Resources,MUIM_Window_SetCycleChain,reslist,CY_ResSort,BT_ResUpdate,BT_ResPrint,BT_ResPriority,BT_ResRemove,BT_ResFunctions,BT_ResMore,BT_ResExit,NULL);
  1303.          DoMethod (CY_ResSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_RESSORT);
  1304.  
  1305.          SetCloseRequest (WI_Resources,ID_RESEXIT);
  1306.          SetListActive (reslist,ID_RESLV_ACTIVE);
  1307.          SetListviewDoubleClick (reslist,ID_RESMORE);
  1308.  
  1309.          ShowResources();
  1310.  
  1311.          SetWindowOpen (WI_Resources,reslist,ID_RESEXIT);
  1312.       }
  1313.    } else if ((! state) && (WI_Resources)) {
  1314.       SetWindowClose (WI_Resources,TRUE);
  1315.  
  1316.       FreeResources();
  1317.  
  1318.       DoMethod (AP_Scout,OM_REMMEMBER,WI_Resources);
  1319.       MUI_DisposeObject (WI_Resources);
  1320.       WI_Resources = NULL;
  1321.       reslist = NULL;
  1322.    }
  1323. }
  1324.  
  1325.  
  1326.